 /**
 * 工具函数集合
 */

/**
 * 格式化金额
 * @param {Number} amount - 金额
 * @param {Number} decimals - 小数位数
 * @returns {String} - 格式化后的金额
 */
export function formatAmount(amount, decimals = 2) {
    if (typeof amount !== 'number') {
      return '0.00'
    }
    return amount.toFixed(decimals)
  }
  
  /**
   * 格式化数字（大于1000显示为k）
   * @param {Number} num - 数字
   * @returns {String} - 格式化后的数字
   */
  export function formatNumber(num) {
    if (typeof num !== 'number') {
      return '0'
    }
    
    if (num >= 1000) {
      return (num / 1000).toFixed(1) + 'k'
    }
    
    return num.toString()
  }
  
  /**
   * 格式化日期时间
   * @param {Date|String|Number} date - 日期对象、时间戳或日期字符串
   * @param {String} format - 格式化模板
   * @returns {String} - 格式化后的日期时间
   */
  export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
    if (!date) {
      return ''
    }
    
    const d = new Date(date)
    
    const year = d.getFullYear()
    const month = d.getMonth() + 1
    const day = d.getDate()
    const hours = d.getHours()
    const minutes = d.getMinutes()
    const seconds = d.getSeconds()
    
    const formatMap = {
      'YYYY': year,
      'MM': month < 10 ? '0' + month : month,
      'DD': day < 10 ? '0' + day : day,
      'HH': hours < 10 ? '0' + hours : hours,
      'mm': minutes < 10 ? '0' + minutes : minutes,
      'ss': seconds < 10 ? '0' + seconds : seconds
    }
    
    return format.replace(/YYYY|MM|DD|HH|mm|ss/g, match => formatMap[match])
  }
  
  /**
   * 获取相对时间
   * @param {Date|String|Number} date - 日期对象、时间戳或日期字符串
   * @returns {String} - 相对时间描述
   */
  export function getRelativeTime(date) {
    if (!date) {
      return ''
    }
    
    const now = new Date()
    const d = new Date(date)
    const diff = now - d
    
    // 转换为秒
    const seconds = Math.floor(diff / 1000)
    
    if (seconds < 60) {
      return '刚刚'
    }
    
    // 转换为分钟
    const minutes = Math.floor(seconds / 60)
    
    if (minutes < 60) {
      return `${minutes}分钟前`
    }
    
    // 转换为小时
    const hours = Math.floor(minutes / 60)
    
    if (hours < 24) {
      return `${hours}小时前`
    }
    
    // 转换为天
    const days = Math.floor(hours / 24)
    
    if (days < 30) {
      return `${days}天前`
    }
    
    // 转换为月
    const months = Math.floor(days / 30)
    
    if (months < 12) {
      return `${months}个月前`
    }
    
    // 转换为年
    const years = Math.floor(months / 12)
    
    return `${years}年前`
  }
  
  /**
   * 深拷贝对象
   * @param {Object} obj - 要拷贝的对象
   * @returns {Object} - 拷贝后的对象
   */
  export function deepClone(obj) {
    if (obj === null || typeof obj !== 'object') {
      return obj
    }
    
    if (obj instanceof Date) {
      return new Date(obj.getTime())
    }
    
    if (obj instanceof Array) {
      return obj.map(item => deepClone(item))
    }
    
    if (obj instanceof Object) {
      const copy = {}
      Object.keys(obj).forEach(key => {
        copy[key] = deepClone(obj[key])
      })
      return copy
    }
    
    return obj
  }
  
  /**
   * 防抖函数
   * @param {Function} fn - 要执行的函数
   * @param {Number} delay - 延迟时间（毫秒）
   * @returns {Function} - 防抖后的函数
   */
  export function debounce(fn, delay = 300) {
    let timer = null
    
    return function(...args) {
      if (timer) {
        clearTimeout(timer)
      }
      
      timer = setTimeout(() => {
        fn.apply(this, args)
      }, delay)
    }
  }
  
  /**
   * 节流函数
   * @param {Function} fn - 要执行的函数
   * @param {Number} interval - 时间间隔（毫秒）
   * @returns {Function} - 节流后的函数
   */
  export function throttle(fn, interval = 300) {
    let lastTime = 0
    
    return function(...args) {
      const now = Date.now()
      
      if (now - lastTime >= interval) {
        lastTime = now
        fn.apply(this, args)
      }
    }
  }
  
  /**
   * 获取URL参数
   * @param {String} name - 参数名
   * @returns {String|null} - 参数值
   */
  export function getUrlParam(name) {
    const url = window.location.href
    name = name.replace(/[\[\]]/g, '\\$&')
    
    const regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)')
    const results = regex.exec(url)
    
    if (!results) return null
    if (!results[2]) return ''
    
    return decodeURIComponent(results[2].replace(/\+/g, ' '))
  }
  
  /**
   * 生成随机ID
   * @param {Number} length - ID长度
   * @returns {String} - 随机ID
   */
  export function generateRandomId(length = 8) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
    let result = ''
    
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length))
    }
    
    return result
  }
  
  /**
   * 格式化距离
   * @param {Number} distance - 距离（米）
   * @returns {String} - 格式化后的距离
   */
  export function formatDistance(distance) {
    if (typeof distance !== 'number') {
      return '未知距离'
    }
    
    if (distance < 1000) {
      return `${Math.round(distance)}米`
    } else {
      return `${(distance / 1000).toFixed(1)}公里`
    }
  }
  
  /**
   * 计算两点之间的距离
   * @param {Array} point1 - 点1的坐标 [经度, 纬度]
   * @param {Array} point2 - 点2的坐标 [经度, 纬度]
   * @returns {Number} - 距离（米）
   */
  export function calculateDistance(point1, point2) {
    const toRad = value => value * Math.PI / 180
    
    const R = 6371000 // 地球半径（米）
    const dLat = toRad(point2[1] - point1[1])
    const dLon = toRad(point2[0] - point1[0])
    
    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
              Math.cos(toRad(point1[1])) * Math.cos(toRad(point2[1])) *
              Math.sin(dLon / 2) * Math.sin(dLon / 2)
    
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
    
    return R * c
  }
  
  /**
   * 本地存储封装
   */
  export const storage = {
    /**
     * 设置本地存储
     * @param {String} key - 键名
     * @param {*} value - 值
     * @param {Boolean} isSession - 是否使用sessionStorage
     */
    set(key, value, isSession = false) {
      const storage = isSession ? sessionStorage : localStorage
      storage.setItem(key, JSON.stringify(value))
    },
    
    /**
     * 获取本地存储
     * @param {String} key - 键名
     * @param {Boolean} isSession - 是否使用sessionStorage
     * @returns {*} - 存储的值
     */
    get(key, isSession = false) {
      const storage = isSession ? sessionStorage : localStorage
      const value = storage.getItem(key)
      
      try {
        return JSON.parse(value)
      } catch (e) {
        return value
      }
    },
    
    /**
     * 移除本地存储
     * @param {String} key - 键名
     * @param {Boolean} isSession - 是否使用sessionStorage
     */
    remove(key, isSession = false) {
      const storage = isSession ? sessionStorage : localStorage
      storage.removeItem(key)
    },
    
    /**
     * 清空本地存储
     * @param {Boolean} isSession - 是否使用sessionStorage
     */
    clear(isSession = false) {
      const storage = isSession ? sessionStorage : localStorage
      storage.clear()
    }
  }